function _extends() {
    _extends =
        Object.assign ||
        function (target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i];

                for (var key in source) {
                    if (Object.prototype.hasOwnProperty.call(source, key)) {
                        target[key] = source[key];
                    }
                }
            }

            return target;
        };

    return _extends.apply(this, arguments);
}

function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    subClass.__proto__ = superClass;
}

function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf
        ? Object.getPrototypeOf
        : function _getPrototypeOf(o) {
              return o.__proto__ || Object.getPrototypeOf(o);
          };
    return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
    _setPrototypeOf =
        Object.setPrototypeOf ||
        function _setPrototypeOf(o, p) {
            o.__proto__ = p;
            return o;
        };

    return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
        Date.prototype.toString.call(
            Reflect.construct(Date, [], function () {})
        );
        return true;
    } catch (e) {
        return false;
    }
}

function _construct(Parent, args, Class) {
    if (_isNativeReflectConstruct()) {
        _construct = Reflect.construct;
    } else {
        _construct = function _construct(Parent, args, Class) {
            var a = [null];
            a.push.apply(a, args);
            var Constructor = Function.bind.apply(Parent, a);
            var instance = new Constructor();
            if (Class) _setPrototypeOf(instance, Class.prototype);
            return instance;
        };
    }

    return _construct.apply(null, arguments);
}

function _isNativeFunction(fn) {
    return Function.toString.call(fn).indexOf("[native code]") !== -1;
}

function _wrapNativeSuper(Class) {
    var _cache = typeof Map === "function" ? new Map() : undefined;

    _wrapNativeSuper = function _wrapNativeSuper(Class) {
        if (Class === null || !_isNativeFunction(Class)) return Class;

        if (typeof Class !== "function") {
            throw new TypeError(
                "Super expression must either be null or a function"
            );
        }

        if (typeof _cache !== "undefined") {
            if (_cache.has(Class)) return _cache.get(Class);

            _cache.set(Class, Wrapper);
        }

        function Wrapper() {
            return _construct(
                Class,
                arguments,
                _getPrototypeOf(this).constructor
            );
        }

        Wrapper.prototype = Object.create(Class.prototype, {
            constructor: {
                value: Wrapper,
                enumerable: false,
                writable: true,
                configurable: true,
            },
        });
        return _setPrototypeOf(Wrapper, Class);
    };

    return _wrapNativeSuper(Class);
}

/* eslint no-console:0 */
var formatRegExp = /%[sdj%]/g;
var warning = function warning() {}; // don't print warning message when in production env or node runtime

if (
    typeof process !== "undefined" &&
    process.env &&
    process.env.NODE_ENV !== "production" &&
    typeof window !== "undefined" &&
    typeof document !== "undefined"
) {
    warning = function warning(type, errors) {
        if (typeof console !== "undefined" && console.warn) {
            if (
                errors.every(function (e) {
                    return typeof e === "string";
                })
            ) {
                console.warn(type, errors);
            }
        }
    };
}

function convertFieldsError(errors) {
    if (!errors || !errors.length) return null;
    var fields = {};
    errors.forEach(function (error) {
        var field = error.field;
        fields[field] = fields[field] || [];
        fields[field].push(error);
    });
    return fields;
}
function format() {
    for (
        var _len = arguments.length, args = new Array(_len), _key = 0;
        _key < _len;
        _key++
    ) {
        args[_key] = arguments[_key];
    }

    var i = 1;
    var f = args[0];
    var len = args.length;

    if (typeof f === "function") {
        return f.apply(null, args.slice(1));
    }

    if (typeof f === "string") {
        var str = String(f).replace(formatRegExp, function (x) {
            if (x === "%%") {
                return "%";
            }

            if (i >= len) {
                return x;
            }

            switch (x) {
                case "%s":
                    return String(args[i++]);

                case "%d":
                    return Number(args[i++]);

                case "%j":
                    try {
                        return JSON.stringify(args[i++]);
                    } catch (_) {
                        return "[Circular]";
                    }

                    break;

                default:
                    return x;
            }
        });

        for (var arg = args[i]; i < len; arg = args[++i]) {
            str += " " + arg;
        }

        return str;
    }

    return f;
}

function isNativeStringType(type) {
    return (
        type === "string" ||
        type === "url" ||
        type === "hex" ||
        type === "email" ||
        type === "pattern"
    );
}

function isEmptyValue(value, type) {
    if (value === undefined || value === null) {
        return true;
    }

    if (type === "array" && Array.isArray(value) && !value.length) {
        return true;
    }

    if (isNativeStringType(type) && typeof value === "string" && !value) {
        return true;
    }

    return false;
}

function asyncParallelArray(arr, func, callback) {
    var results = [];
    var total = 0;
    var arrLength = arr.length;

    function count(errors) {
        results.push.apply(results, errors);
        total++;

        if (total === arrLength) {
            callback(results);
        }
    }

    arr.forEach(function (a) {
        func(a, count);
    });
}

function asyncSerialArray(arr, func, callback) {
    var index = 0;
    var arrLength = arr.length;

    function next(errors) {
        if (errors && errors.length) {
            callback(errors);
            return;
        }

        var original = index;
        index = index + 1;

        if (original < arrLength) {
            func(arr[original], next);
        } else {
            callback([]);
        }
    }

    next([]);
}

function flattenObjArr(objArr) {
    var ret = [];
    Object.keys(objArr).forEach(function (k) {
        ret.push.apply(ret, objArr[k]);
    });
    return ret;
}

var AsyncValidationError = /*#__PURE__*/ (function (_Error) {
    _inheritsLoose(AsyncValidationError, _Error);

    function AsyncValidationError(errors, fields) {
        var _this;

        _this = _Error.call(this, "Async Validation Error") || this;
        _this.errors = errors;
        _this.fields = fields;
        return _this;
    }

    return AsyncValidationError;
})(/*#__PURE__*/ _wrapNativeSuper(Error));
function asyncMap(objArr, option, func, callback) {
    if (option.first) {
        var _pending = new Promise(function (resolve, reject) {
            var next = function next(errors) {
                callback(errors);
                return errors.length
                    ? reject(
                          new AsyncValidationError(
                              errors,
                              convertFieldsError(errors)
                          )
                      )
                    : resolve();
            };

            var flattenArr = flattenObjArr(objArr);
            asyncSerialArray(flattenArr, func, next);
        });

        _pending["catch"](function (e) {
            return e;
        });

        return _pending;
    }

    var firstFields = option.firstFields || [];

    if (firstFields === true) {
        firstFields = Object.keys(objArr);
    }

    var objArrKeys = Object.keys(objArr);
    var objArrLength = objArrKeys.length;
    var total = 0;
    var results = [];
    var pending = new Promise(function (resolve, reject) {
        var next = function next(errors) {
            results.push.apply(results, errors);
            total++;

            if (total === objArrLength) {
                callback(results);
                return results.length
                    ? reject(
                          new AsyncValidationError(
                              results,
                              convertFieldsError(results)
                          )
                      )
                    : resolve();
            }
        };

        if (!objArrKeys.length) {
            callback(results);
            resolve();
        }

        objArrKeys.forEach(function (key) {
            var arr = objArr[key];

            if (firstFields.indexOf(key) !== -1) {
                asyncSerialArray(arr, func, next);
            } else {
                asyncParallelArray(arr, func, next);
            }
        });
    });
    pending["catch"](function (e) {
        return e;
    });
    return pending;
}
function complementError(rule) {
    return function (oe) {
        if (oe && oe.message) {
            oe.field = oe.field || rule.fullField;
            return oe;
        }

        return {
            message: typeof oe === "function" ? oe() : oe,
            field: oe.field || rule.fullField,
        };
    };
}
function deepMerge(target, source) {
    if (source) {
        for (var s in source) {
            if (source.hasOwnProperty(s)) {
                var value = source[s];

                if (
                    typeof value === "object" &&
                    typeof target[s] === "object"
                ) {
                    target[s] = _extends(_extends({}, target[s]), value);
                } else {
                    target[s] = value;
                }
            }
        }
    }

    return target;
}

/**
 *  Rule for validating required fields.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function required(rule, value, source, errors, options, type) {
    if (
        rule.required &&
        (!source.hasOwnProperty(rule.field) ||
            isEmptyValue(value, type || rule.type))
    ) {
        errors.push(format(options.messages.required, rule.fullField));
    }
}

/**
 *  Rule for validating whitespace.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function whitespace(rule, value, source, errors, options) {
    if (/^\s+$/.test(value) || value === "") {
        errors.push(format(options.messages.whitespace, rule.fullField));
    }
}

/* eslint max-len:0 */

var pattern = {
    // http://emailregex.com/
    email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
    url: new RegExp(
        "^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$",
        "i"
    ),
    hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
};
var types = {
    integer: function integer(value) {
        return types.number(value) && parseInt(value, 10) === value;
    },
    float: function float(value) {
        return types.number(value) && !types.integer(value);
    },
    array: function array(value) {
        return Array.isArray(value);
    },
    regexp: function regexp(value) {
        if (value instanceof RegExp) {
            return true;
        }

        try {
            return !!new RegExp(value);
        } catch (e) {
            return false;
        }
    },
    date: function date(value) {
        return (
            typeof value.getTime === "function" &&
            typeof value.getMonth === "function" &&
            typeof value.getYear === "function"
        );
    },
    number: function number(value) {
        if (isNaN(value)) {
            return false;
        }

        return typeof value === "number";
    },
    object: function object(value) {
        return typeof value === "object" && !types.array(value);
    },
    method: function method(value) {
        return typeof value === "function";
    },
    email: function email(value) {
        return (
            typeof value === "string" &&
            !!value.match(pattern.email) &&
            value.length < 255
        );
    },
    url: function url(value) {
        return typeof value === "string" && !!value.match(pattern.url);
    },
    hex: function hex(value) {
        return typeof value === "string" && !!value.match(pattern.hex);
    },
};
/**
 *  Rule for validating the type of a value.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function type(rule, value, source, errors, options) {
    if (rule.required && value === undefined) {
        required(rule, value, source, errors, options);
        return;
    }

    var custom = [
        "integer",
        "float",
        "array",
        "regexp",
        "object",
        "method",
        "email",
        "number",
        "date",
        "url",
        "hex",
    ];
    var ruleType = rule.type;

    if (custom.indexOf(ruleType) > -1) {
        if (!types[ruleType](value)) {
            errors.push(
                format(
                    options.messages.types[ruleType],
                    rule.fullField,
                    rule.type
                )
            );
        } // straight typeof check
    } else if (ruleType && typeof value !== rule.type) {
        errors.push(
            format(options.messages.types[ruleType], rule.fullField, rule.type)
        );
    }
}

/**
 *  Rule for validating minimum and maximum allowed values.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function range(rule, value, source, errors, options) {
    var len = typeof rule.len === "number";
    var min = typeof rule.min === "number";
    var max = typeof rule.max === "number"; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）

    var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
    var val = value;
    var key = null;
    var num = typeof value === "number";
    var str = typeof value === "string";
    var arr = Array.isArray(value);

    if (num) {
        key = "number";
    } else if (str) {
        key = "string";
    } else if (arr) {
        key = "array";
    } // if the value is not of a supported type for range validation
    // the validation rule rule should use the
    // type property to also test for a particular type

    if (!key) {
        return false;
    }

    if (arr) {
        val = value.length;
    }

    if (str) {
        // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
        val = value.replace(spRegexp, "_").length;
    }

    if (len) {
        if (val !== rule.len) {
            errors.push(
                format(options.messages[key].len, rule.fullField, rule.len)
            );
        }
    } else if (min && !max && val < rule.min) {
        errors.push(
            format(options.messages[key].min, rule.fullField, rule.min)
        );
    } else if (max && !min && val > rule.max) {
        errors.push(
            format(options.messages[key].max, rule.fullField, rule.max)
        );
    } else if (min && max && (val < rule.min || val > rule.max)) {
        errors.push(
            format(
                options.messages[key].range,
                rule.fullField,
                rule.min,
                rule.max
            )
        );
    }
}

var ENUM = "enum";
/**
 *  Rule for validating a value exists in an enumerable list.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function enumerable(rule, value, source, errors, options) {
    rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];

    if (rule[ENUM].indexOf(value) === -1) {
        errors.push(
            format(
                options.messages[ENUM],
                rule.fullField,
                rule[ENUM].join(", ")
            )
        );
    }
}

/**
 *  Rule for validating a regular expression pattern.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function pattern$1(rule, value, source, errors, options) {
    if (rule.pattern) {
        if (rule.pattern instanceof RegExp) {
            // if a RegExp instance is passed, reset `lastIndex` in case its `global`
            // flag is accidentally set to `true`, which in a validation scenario
            // is not necessary and the result might be misleading
            rule.pattern.lastIndex = 0;

            if (!rule.pattern.test(value)) {
                errors.push(
                    format(
                        options.messages.pattern.mismatch,
                        rule.fullField,
                        value,
                        rule.pattern
                    )
                );
            }
        } else if (typeof rule.pattern === "string") {
            var _pattern = new RegExp(rule.pattern);

            if (!_pattern.test(value)) {
                errors.push(
                    format(
                        options.messages.pattern.mismatch,
                        rule.fullField,
                        value,
                        rule.pattern
                    )
                );
            }
        }
    }
}

var rules = {
    required: required,
    whitespace: whitespace,
    type: type,
    range: range,
    enum: enumerable,
    pattern: pattern$1,
};

/**
 *  Performs validation for string types.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function string(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value, "string") && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options, "string");

        if (!isEmptyValue(value, "string")) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
            rules.pattern(rule, value, source, errors, options);

            if (rule.whitespace === true) {
                rules.whitespace(rule, value, source, errors, options);
            }
        }
    }

    callback(errors);
}

/**
 *  Validates a function.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function method(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates a number.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function number(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (value === "") {
            value = undefined;
        }

        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates a boolean.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function _boolean(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates the regular expression type.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function regexp(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (!isEmptyValue(value)) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates a number is an integer.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function integer(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates a number is a floating point number.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function floatFn(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates an array.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function array(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value, "array") && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options, "array");

        if (!isEmptyValue(value, "array")) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates an object.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function object(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

var ENUM$1 = "enum";
/**
 *  Validates an enumerable list.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function enumerable$1(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules[ENUM$1](rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Validates a regular expression pattern.
 *
 *  Performs validation when a rule only contains
 *  a pattern property but is not declared as a string type.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function pattern$2(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value, "string") && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (!isEmptyValue(value, "string")) {
            rules.pattern(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

function date(rule, value, callback, source, options) {
    // console.log('integer rule called %j', rule);
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field)); // console.log('validate on %s value', value);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (!isEmptyValue(value)) {
            var dateObject;

            if (typeof value === "number") {
                dateObject = new Date(value);
            } else {
                dateObject = value;
            }

            rules.type(rule, dateObject, source, errors, options);

            if (dateObject) {
                rules.range(
                    rule,
                    dateObject.getTime(),
                    source,
                    errors,
                    options
                );
            }
        }
    }

    callback(errors);
}

function required$1(rule, value, callback, source, options) {
    var errors = [];
    var type = Array.isArray(value) ? "array" : typeof value;
    rules.required(rule, value, source, errors, options, type);
    callback(errors);
}

function type$1(rule, value, callback, source, options) {
    var ruleType = rule.type;
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value, ruleType) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options, ruleType);

        if (!isEmptyValue(value, ruleType)) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
}

/**
 *  Performs validation for any type.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function any(rule, value, callback, source, options) {
    var errors = [];
    var validate =
        rule.required || (!rule.required && source.hasOwnProperty(rule.field));

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);
    }

    callback(errors);
}

var validators = {
    string: string,
    method: method,
    number: number,
    boolean: _boolean,
    regexp: regexp,
    integer: integer,
    float: floatFn,
    array: array,
    object: object,
    enum: enumerable$1,
    pattern: pattern$2,
    date: date,
    url: type$1,
    hex: type$1,
    email: type$1,
    required: required$1,
    any: any,
};

function newMessages() {
    return {
        default: "Validation error on field %s",
        required: "%s is required",
        enum: "%s must be one of %s",
        whitespace: "%s cannot be empty",
        date: {
            format: "%s date %s is invalid for format %s",
            parse: "%s date could not be parsed, %s is invalid ",
            invalid: "%s date %s is invalid",
        },
        types: {
            string: "%s is not a %s",
            method: "%s is not a %s (function)",
            array: "%s is not an %s",
            object: "%s is not an %s",
            number: "%s is not a %s",
            date: "%s is not a %s",
            boolean: "%s is not a %s",
            integer: "%s is not an %s",
            float: "%s is not a %s",
            regexp: "%s is not a valid %s",
            email: "%s is not a valid %s",
            url: "%s is not a valid %s",
            hex: "%s is not a valid %s",
        },
        string: {
            len: "%s must be exactly %s characters",
            min: "%s must be at least %s characters",
            max: "%s cannot be longer than %s characters",
            range: "%s must be between %s and %s characters",
        },
        number: {
            len: "%s must equal %s",
            min: "%s cannot be less than %s",
            max: "%s cannot be greater than %s",
            range: "%s must be between %s and %s",
        },
        array: {
            len: "%s must be exactly %s in length",
            min: "%s cannot be less than %s in length",
            max: "%s cannot be greater than %s in length",
            range: "%s must be between %s and %s in length",
        },
        pattern: {
            mismatch: "%s value %s does not match pattern %s",
        },
        clone: function clone() {
            var cloned = JSON.parse(JSON.stringify(this));
            cloned.clone = this.clone;
            return cloned;
        },
    };
}
var messages = newMessages();

/**
 *  Encapsulates a validation schema.
 *
 *  @param descriptor An object declaring validation rules
 *  for this schema.
 */

function Schema(descriptor) {
    this.rules = null;
    this._messages = messages;
    this.define(descriptor);
}

Schema.prototype = {
    messages: function messages(_messages) {
        if (_messages) {
            this._messages = deepMerge(newMessages(), _messages);
        }

        return this._messages;
    },
    define: function define(rules) {
        if (!rules) {
            throw new Error("Cannot configure a schema with no rules");
        }

        if (typeof rules !== "object" || Array.isArray(rules)) {
            throw new Error("Rules must be an object");
        }

        this.rules = {};
        var z;
        var item;

        for (z in rules) {
            if (rules.hasOwnProperty(z)) {
                item = rules[z];
                this.rules[z] = Array.isArray(item) ? item : [item];
            }
        }
    },
    validate: function validate(source_, o, oc) {
        var _this = this;

        if (o === void 0) {
            o = {};
        }

        if (oc === void 0) {
            oc = function oc() {};
        }

        var source = source_;
        var options = o;
        var callback = oc;

        if (typeof options === "function") {
            callback = options;
            options = {};
        }

        if (!this.rules || Object.keys(this.rules).length === 0) {
            if (callback) {
                callback();
            }

            return Promise.resolve();
        }

        function complete(results) {
            var i;
            var errors = [];
            var fields = {};

            function add(e) {
                if (Array.isArray(e)) {
                    var _errors;

                    errors = (_errors = errors).concat.apply(_errors, e);
                } else {
                    errors.push(e);
                }
            }

            for (i = 0; i < results.length; i++) {
                add(results[i]);
            }

            if (!errors.length) {
                errors = null;
                fields = null;
            } else {
                fields = convertFieldsError(errors);
            }

            callback(errors, fields);
        }

        if (options.messages) {
            var messages$1 = this.messages();

            if (messages$1 === messages) {
                messages$1 = newMessages();
            }

            deepMerge(messages$1, options.messages);
            options.messages = messages$1;
        } else {
            options.messages = this.messages();
        }

        var arr;
        var value;
        var series = {};
        var keys = options.keys || Object.keys(this.rules);
        keys.forEach(function (z) {
            arr = _this.rules[z];
            value = source[z];
            arr.forEach(function (r) {
                var rule = r;

                if (typeof rule.transform === "function") {
                    if (source === source_) {
                        source = _extends({}, source);
                    }

                    value = source[z] = rule.transform(value);
                }

                if (typeof rule === "function") {
                    rule = {
                        validator: rule,
                    };
                } else {
                    rule = _extends({}, rule);
                }

                rule.validator = _this.getValidationMethod(rule);
                rule.field = z;
                rule.fullField = rule.fullField || z;
                rule.type = _this.getType(rule);

                if (!rule.validator) {
                    return;
                }

                series[z] = series[z] || [];
                series[z].push({
                    rule: rule,
                    value: value,
                    source: source,
                    field: z,
                });
            });
        });
        var errorFields = {};
        return asyncMap(
            series,
            options,
            function (data, doIt) {
                var rule = data.rule;
                var deep =
                    (rule.type === "object" || rule.type === "array") &&
                    (typeof rule.fields === "object" ||
                        typeof rule.defaultField === "object");
                deep =
                    deep && (rule.required || (!rule.required && data.value));
                rule.field = data.field;

                function addFullfield(key, schema) {
                    return _extends(
                        _extends({}, schema),
                        {},
                        {
                            fullField: rule.fullField + "." + key,
                        }
                    );
                }

                function cb(e) {
                    if (e === void 0) {
                        e = [];
                    }

                    var errors = e;

                    if (!Array.isArray(errors)) {
                        errors = [errors];
                    }

                    if (!options.suppressWarning && errors.length) {
                        Schema.warning("async-validator:", errors);
                    }

                    if (errors.length && rule.message) {
                        errors = [].concat(rule.message);
                    }

                    errors = errors.map(complementError(rule));

                    if (options.first && errors.length) {
                        errorFields[rule.field] = 1;
                        return doIt(errors);
                    }

                    if (!deep) {
                        doIt(errors);
                    } else {
                        // if rule is required but the target object
                        // does not exist fail at the rule level and don't
                        // go deeper
                        if (rule.required && !data.value) {
                            if (rule.message) {
                                errors = []
                                    .concat(rule.message)
                                    .map(complementError(rule));
                            } else if (options.error) {
                                errors = [
                                    options.error(
                                        rule,
                                        format(
                                            options.messages.required,
                                            rule.field
                                        )
                                    ),
                                ];
                            }

                            return doIt(errors);
                        }

                        var fieldsSchema = {};

                        if (rule.defaultField) {
                            for (var k in data.value) {
                                if (data.value.hasOwnProperty(k)) {
                                    fieldsSchema[k] = rule.defaultField;
                                }
                            }
                        }

                        fieldsSchema = _extends(
                            _extends({}, fieldsSchema),
                            data.rule.fields
                        );

                        for (var f in fieldsSchema) {
                            if (fieldsSchema.hasOwnProperty(f)) {
                                var fieldSchema = Array.isArray(fieldsSchema[f])
                                    ? fieldsSchema[f]
                                    : [fieldsSchema[f]];
                                fieldsSchema[f] = fieldSchema.map(
                                    addFullfield.bind(null, f)
                                );
                            }
                        }

                        var schema = new Schema(fieldsSchema);
                        schema.messages(options.messages);

                        if (data.rule.options) {
                            data.rule.options.messages = options.messages;
                            data.rule.options.error = options.error;
                        }

                        schema.validate(
                            data.value,
                            data.rule.options || options,
                            function (errs) {
                                var finalErrors = [];

                                if (errors && errors.length) {
                                    finalErrors.push.apply(finalErrors, errors);
                                }

                                if (errs && errs.length) {
                                    finalErrors.push.apply(finalErrors, errs);
                                }

                                doIt(finalErrors.length ? finalErrors : null);
                            }
                        );
                    }
                }

                var res;

                if (rule.asyncValidator) {
                    res = rule.asyncValidator(
                        rule,
                        data.value,
                        cb,
                        data.source,
                        options
                    );
                } else if (rule.validator) {
                    res = rule.validator(
                        rule,
                        data.value,
                        cb,
                        data.source,
                        options
                    );

                    if (res === true) {
                        cb();
                    } else if (res === false) {
                        cb(rule.message || rule.field + " fails");
                    } else if (res instanceof Array) {
                        cb(res);
                    } else if (res instanceof Error) {
                        cb(res.message);
                    }
                }

                if (res && res.then) {
                    res.then(
                        function () {
                            return cb();
                        },
                        function (e) {
                            return cb(e);
                        }
                    );
                }
            },
            function (results) {
                complete(results);
            }
        );
    },
    getType: function getType(rule) {
        if (rule.type === undefined && rule.pattern instanceof RegExp) {
            rule.type = "pattern";
        }

        if (
            typeof rule.validator !== "function" &&
            rule.type &&
            !validators.hasOwnProperty(rule.type)
        ) {
            throw new Error(format("Unknown rule type %s", rule.type));
        }

        return rule.type || "string";
    },
    getValidationMethod: function getValidationMethod(rule) {
        if (typeof rule.validator === "function") {
            return rule.validator;
        }

        var keys = Object.keys(rule);
        var messageIndex = keys.indexOf("message");

        if (messageIndex !== -1) {
            keys.splice(messageIndex, 1);
        }

        if (keys.length === 1 && keys[0] === "required") {
            return validators.required;
        }

        return validators[this.getType(rule)] || false;
    },
};

Schema.register = function register(type, validator) {
    if (typeof validator !== "function") {
        throw new Error(
            "Cannot register a validator by type, validator is not a function"
        );
    }

    validators[type] = validator;
};

Schema.warning = warning;
Schema.messages = messages;
Schema.validators = validators;

window.Schema = Schema;
